repowire 0.8.0

Mesh network for AI coding agents - enables Claude Code and OpenCode sessions to communicate

Repowire

Mesh network for AI coding agents — enables Claude Code and OpenCode sessions to communicate.

Why?

AI coding agents work great in a single repo, but multi-repo projects need a context breakout — a way to get information from other codebases. Most solutions are async context breakouts: memory banks, docs, persisted context. Repowire is a sync context breakout: live agents talking to each other about current code. Your frontend Claude can ask backend about API shapes and get a real answer from the actual codebase.

Read more: the context breakout problem and the idea behind Repowire.

How does repowire compare?

Project	Type	How it works	Best for
Repowire	Sync	Live agent-to-agent queries	Cross-repo collaboration, 5-10 peers
Gastown	Async	Work orchestration with persistent mail	Coordinated fleets, 20-30 agents
Claude Squad	Isolated	Session management with worktrees	Multiple independent sessions
Memory Bank	Async	Structured markdown files	Persistent project knowledge

Repowire is a phone call (real-time, ephemeral). Gastown is email + project manager (async, persistent). For 5-10 agents, emergence works. For 20-30 grinding through backlogs, you probably need structure.

https://github.com/user-attachments/assets/e356ce7c-9454-4e41-93af-3991c6f391b9

Installation

Requirements: macOS or Linux, Python 3.10+, tmux

uv tool install repowire
# or: pip install repowire

Quick Start

# One-time setup — installs hooks, MCP server, and daemon service
repowire setup

# Verify everything is running
repowire status

Spawn two peers:

repowire peer new ~/projects/frontend --circle dev
repowire peer new ~/projects/backend --circle dev

The sessions auto-discover each other. In frontend's Claude:

"Ask backend what API endpoints they expose"

Claude uses the ask_peer tool, backend responds, and you get the answer back.

How It Works

All peers connect to a central daemon via WebSocket. The daemon routes addressed messages between peers — no pub/sub, no topics. Messages go from peer A to peer B by name.

┌──────────────┐          ┌──────────────┐          ┌──────────────┐
│   Claude     │  channel │              │    WS    │   OpenCode   │
│   frontend   │◄────────►│    Daemon    │◄────────►│   api        │
└──────────────┘   (MCP)  │  :8377       │          └──────────────┘
                          │              │
┌──────────────┐  channel │              │
│   Claude     │◄────────►│              │
│   backend    │   (MCP)  └──────────────┘
└──────────────┘

Message types:

• ask_peer — request/response with correlation ID (blocks until answer, 300s timeout)
• notify_peer — fire-and-forget (no response expected)
• broadcast — fan-out to all peers in your circle

Circles are logical subnets (mapped to tmux sessions). Peers can only communicate within their circle unless explicitly bypassed.

Claude Code Transport

By default, repowire uses hooks + tmux injection — lifecycle hooks that handle peer registration, message delivery via tmux send-keys, and transcript scraping for responses.

• SessionStart — registers peer, spawns WebSocket hook, injects peer list as context
• UserPromptSubmit — marks peer BUSY
• Stop — extracts response from transcript, delivers query responses, posts chat turns for dashboard
• Notification (idle_prompt) — resets BUSY→ONLINE after interrupt

Experimental: channel transport

On Claude Code v2.1.80+ with claude.ai login and bun, an experimental channel transport delivers messages directly into Claude's context via MCP, with no tmux injection.

repowire setup --experimental-channels

Claude Code ←stdio→ repowire-channel (MCP) ←WebSocket→ Daemon

• Messages arrive as <channel source="repowire" from_peer="..." msg_type="..."> tags
• Claude replies via reply tool instead of transcript scraping
• Requires claude.ai login (not available for API/Console key auth)

OpenCode integration

OpenCode has a plugin SDK. The repowire plugin (~/.opencode/plugin/repowire.ts) maintains a persistent WebSocket connection and uses client.session.prompt() to inject queries.

Control Plane

Web Dashboard

Monitor your agent mesh at http://localhost:8377/dashboard, or remotely via repowire.io:

• Peer overview — online/busy/offline status, descriptions, project paths
• Chat view — conversation history per peer with tool call details
• Compose bar — send notifications or queries to any peer from the browser
• Mobile responsive — hamburger menu, touch-friendly compose

For remote access: repowire setup --relay connects your daemon to repowire.io via outbound WebSocket. Access your dashboard from any browser — no port forwarding, no VPN.

More screenshots

Telegram Bot

Control your mesh from your phone. A Telegram bot registers as a peer — notifications from agents appear in your chat, messages you send get routed to peers.

TELEGRAM_BOT_TOKEN="..." TELEGRAM_CHAT_ID="..." repowire telegram start

• /peers — shows online peers with inline buttons
• Tap a peer → type your message → sent as notification
• Sticky routing: /select repowire → all messages go there until /clear
• Agents know @telegram is you — they can notify_peer('telegram', ...) to reach your phone

MCP Tools

Tool	Type	Description
list_peers	Query	List all peers with status, circle, path, description
ask_peer	Blocking	Send a question and wait for the response
notify_peer	Fire-and-forget	Send a notification — peer can notify_peer back when ready
broadcast	Fire-and-forget	Message all online peers in your circle
whoami	Query	Your own peer identity
set_description	Mutation	Update your task description, visible to all peers and the dashboard
spawn_peer	Mutation	Spawn a new agent session (requires allowlist config)
kill_peer	Mutation	Kill a previously spawned session

list_peers and whoami return TSV (more token-efficient than JSON). For long-running requests, prefer notify_peer over ask_peer.

CLI Reference

repowire setup                    # Install hooks, MCP server, daemon service
repowire setup --relay            # Same + enable remote dashboard via repowire.io
repowire setup --experimental-channels  # Use channel transport (needs claude.ai login + bun)
repowire status                   # Show what's installed and running
repowire serve                    # Run daemon in foreground
repowire serve --relay            # Run daemon with relay connection

repowire peer new PATH            # Spawn new peer in tmux
repowire peer new . --circle dev  # Spawn with custom circle
repowire peer list                # List peers and their status
repowire peer prune               # Remove offline peers

repowire telegram start           # Run Telegram bot (needs env vars)
repowire slack start              # Run Slack bot (needs env vars)
repowire uninstall                # Remove all components

Configuration

Config file: ~/.repowire/config.yaml

daemon:
  host: "127.0.0.1"
  port: 8377
  auth_token: "optional-secret"     # Require auth for WebSocket connections

  # Allow agents to spawn new sessions via MCP (both lists must be non-empty)
  spawn:
    allowed_commands:
      - claude
      - claude --dangerously-skip-permissions
    allowed_paths:
      - ~/git
      - ~/projects

relay:
  enabled: true                     # Connect to hosted relay
  url: "wss://repowire.io"
  api_key: "rw_..."                 # Auto-generated on first `repowire serve --relay`

Peers auto-register via WebSocket on session start — no manual config needed.

Remote relay details

repowire setup --relay
# ✓ Relay enabled
#   Dashboard: https://repowire.io/dashboard

Your daemon opens an outbound WebSocket to repowire.io. The relay bridges messages between daemons on different machines and proxies HTTP requests (dashboard, API) back through a cookie-authenticated tunnel.

Browser → repowire.io → enter key → cookie set → relay tunnels to local daemon
Daemon A ←WSS→ repowire.io ←WSS→ Daemon B (cross-machine mesh)

Self-host the relay: repowire relay start --port 8000

Security

• WebSocket auth — set daemon.auth_token in config to require bearer token for connections
• CORS — restricted to localhost origins (plus repowire.io when relay is enabled)
• Spawn allowlist — daemon.spawn.allowed_commands and allowed_paths must both be non-empty for MCP spawn to work
• Channel gating — channel transport is opt-in (--experimental-channels), requires claude.ai login

License

MIT